// Zombie sounds
new Array:class_sound_infect, Array:class_sound_pain, Array:class_sound_idle,
Array:class_sound_idle_last, Array:class_sound_die, Array:class_sound_fall,
Array:class_sound_madness, Array:class_sound_burn, Array:class_sound_miss_slash,
Array:class_sound_miss_wall, Array:class_sound_hit_normal, Array:class_sound_hit_stab,
Array:pointer_class_sound_infect, Array:pointer_class_sound_pain, Array:pointer_class_sound_idle,
Array:pointer_class_sound_idle_last, Array:pointer_class_sound_die, Array:pointer_class_sound_fall,
Array:pointer_class_sound_madness, Array:pointer_class_sound_burn, Array:pointer_class_sound_miss_slash,
Array:pointer_class_sound_miss_wall, Array:pointer_class_sound_hit_normal, Array:pointer_class_sound_hit_stab

// Nemesis sounds
new Array:nemesis_pain, Array:nemesis_idle, Array:nemesis_die,
Array:nemesis_fall, Array:nemesis_miss_slash, Array:nemesis_miss_wall,
Array:nemesis_hit_normal, Array:nemesis_hit_stab

	nemesis_pain = ArrayCreate(64, 1)
	nemesis_idle = ArrayCreate(64, 1)
	nemesis_die = ArrayCreate(64, 1)
	nemesis_fall = ArrayCreate(64, 1)
	nemesis_miss_slash = ArrayCreate(64, 1)
	nemesis_miss_wall = ArrayCreate(64, 1)
	nemesis_hit_normal = ArrayCreate(64, 1)
	nemesis_hit_stab = ArrayCreate(64, 1)
	class_sound_infect = ArrayCreate(64, 1)
	class_sound_pain = ArrayCreate(64, 1)
	class_sound_idle = ArrayCreate(64, 1)
	class_sound_idle_last = ArrayCreate(64, 1)
	class_sound_die = ArrayCreate(64, 1)
	class_sound_fall = ArrayCreate(64, 1)
	class_sound_madness = ArrayCreate(64, 1)
	class_sound_burn = ArrayCreate(64, 1)
	class_sound_miss_slash = ArrayCreate(64, 1)
	class_sound_miss_wall = ArrayCreate(64, 1)
	class_sound_hit_normal = ArrayCreate(64, 1)
	class_sound_hit_stab = ArrayCreate(64, 1)
	pointer_class_sound_infect = ArrayCreate(10, 1)
	pointer_class_sound_pain = ArrayCreate(10, 1)
	pointer_class_sound_idle = ArrayCreate(10, 1)
	pointer_class_sound_idle_last = ArrayCreate(10, 1)
	pointer_class_sound_die = ArrayCreate(10, 1)
	pointer_class_sound_fall = ArrayCreate(64, 1)
	pointer_class_sound_madness = ArrayCreate(10, 1)
	pointer_class_sound_burn = ArrayCreate(10, 1)
	pointer_class_sound_miss_slash = ArrayCreate(64, 1)
	pointer_class_sound_miss_wall = ArrayCreate(64, 1)
	pointer_class_sound_hit_normal = ArrayCreate(64, 1)
	pointer_class_sound_hit_stab = ArrayCreate(64, 1)

	for (i = 0; i < ArraySize(nemesis_pain); i++)
	{
		ArrayGetString(nemesis_pain, i, buffer, charsmax(buffer))
		engfunc(EngFunc_PrecacheSound, buffer)
	}
	for (i = 0; i < ArraySize(nemesis_idle); i++)
	{
		ArrayGetString(nemesis_idle, i, buffer, charsmax(buffer))
		engfunc(EngFunc_PrecacheSound, buffer)
	}
	for (i = 0; i < ArraySize(nemesis_die); i++)
	{
		ArrayGetString(nemesis_die, i, buffer, charsmax(buffer))
		engfunc(EngFunc_PrecacheSound, buffer)
	}
	for (i = 0; i < ArraySize(nemesis_fall); i++)
	{
		ArrayGetString(nemesis_fall, i, buffer, charsmax(buffer))
		engfunc(EngFunc_PrecacheSound, buffer)
	}
	for (i = 0; i < ArraySize(nemesis_miss_slash); i++)
	{
		ArrayGetString(nemesis_miss_slash, i, buffer, charsmax(buffer))
		engfunc(EngFunc_PrecacheSound, buffer)
	}
	for (i = 0; i < ArraySize(nemesis_miss_wall); i++)
	{
		ArrayGetString(nemesis_miss_wall, i, buffer, charsmax(buffer))
		engfunc(EngFunc_PrecacheSound, buffer)
	}
	for (i = 0; i < ArraySize(nemesis_hit_normal); i++)
	{
		ArrayGetString(nemesis_hit_normal, i, buffer, charsmax(buffer))
		engfunc(EngFunc_PrecacheSound, buffer)
	}
	for (i = 0; i < ArraySize(nemesis_hit_stab); i++)
	{
		ArrayGetString(nemesis_hit_stab, i, buffer, charsmax(buffer))
		engfunc(EngFunc_PrecacheSound, buffer)
	}
	for (i = 0; i < ArraySize(class_sound_infect); i++)
	{
		ArrayGetString(class_sound_infect, i, buffer, charsmax(buffer))
		engfunc(EngFunc_PrecacheSound, buffer)
	}
	for (i = 0; i < ArraySize(class_sound_pain); i++)
	{
		ArrayGetString(class_sound_pain, i, buffer, charsmax(buffer))
		engfunc(EngFunc_PrecacheSound, buffer)
	}
	for (i = 0; i < ArraySize(class_sound_idle); i++)
	{
		ArrayGetString(class_sound_idle, i, buffer, charsmax(buffer))
		engfunc(EngFunc_PrecacheSound, buffer)
	}
	for (i = 0; i < ArraySize(class_sound_idle_last); i++)
	{
		ArrayGetString(class_sound_idle_last, i, buffer, charsmax(buffer))
		engfunc(EngFunc_PrecacheSound, buffer)
	}
	for (i = 0; i < ArraySize(class_sound_die); i++)
	{
		ArrayGetString(class_sound_die, i, buffer, charsmax(buffer))
		engfunc(EngFunc_PrecacheSound, buffer)
	}
	for (i = 0; i < ArraySize(class_sound_fall); i++)
	{
		ArrayGetString(class_sound_fall, i, buffer, charsmax(buffer))
		engfunc(EngFunc_PrecacheSound, buffer)
	}
	for (i = 0; i < ArraySize(class_sound_madness); i++)
	{
		ArrayGetString(class_sound_madness, i, buffer, charsmax(buffer))
		engfunc(EngFunc_PrecacheSound, buffer)
	}
	for (i = 0; i < ArraySize(class_sound_burn); i++)
	{
		ArrayGetString(class_sound_burn, i, buffer, charsmax(buffer))
		engfunc(EngFunc_PrecacheSound, buffer)
	}
	for (i = 0; i < ArraySize(class_sound_miss_slash); i++)
	{
		ArrayGetString(class_sound_miss_slash, i, buffer, charsmax(buffer))
		engfunc(EngFunc_PrecacheSound, buffer)
	}
	for (i = 0; i < ArraySize(class_sound_miss_wall); i++)
	{
		ArrayGetString(class_sound_miss_wall, i, buffer, charsmax(buffer))
		engfunc(EngFunc_PrecacheSound, buffer)
	}
	for (i = 0; i < ArraySize(class_sound_hit_normal); i++)
	{
		ArrayGetString(class_sound_hit_normal, i, buffer, charsmax(buffer))
		engfunc(EngFunc_PrecacheSound, buffer)
	}
	for (i = 0; i < ArraySize(class_sound_hit_stab); i++)
	{
		ArrayGetString(class_sound_hit_stab, i, buffer, charsmax(buffer))
		engfunc(EngFunc_PrecacheSound, buffer)
	}

Находим:
			// Infection sound
			ArrayGetString(zombie_infect, random_num(0, ArraySize(zombie_infect) - 1), sound, charsmax(sound))
			emit_sound(id, CHAN_VOICE, sound, 1.0, ATTN_NORM, 0, PITCH_NORM)
Заменяем на:
			// Infection sound
			static pointers[10], end
			ArrayGetArray(pointer_class_sound_infect, g_zombieclass[id], pointers)
			
			for (new i; i < 10; i++)
			{
				if (pointers[i] != -1)
				end = i
			}
			ArrayGetString(class_sound_infect, random_num(pointers[0], pointers[end]), sound, charsmax(sound))
			emit_sound(id, CHAN_VOICE, sound, 1.0, ATTN_NORM, 0, PITCH_NORM)

Ниже находим:
			// Infection sound
			ArrayGetString(zombie_infect, random_num(0, ArraySize(zombie_infect) - 1), sound, charsmax(sound))
			emit_sound(id, CHAN_VOICE, sound, 1.0, ATTN_NORM, 0, PITCH_NORM)
Так же заменяем на:
			// Infection sound
			static pointers[10], end
			ArrayGetArray(pointer_class_sound_infect, g_zombieclass[id], pointers)
			
			for (new i; i < 10; i++)
			{
				if (pointers[i] != -1)
				end = i
			}
			ArrayGetString(class_sound_infect, random_num(pointers[0], pointers[end]), sound, charsmax(sound))
			emit_sound(id, CHAN_VOICE, sound, 1.0, ATTN_NORM, 0, PITCH_NORM)

Находим:
	// Zombie being hit
	if (sample[7] == 'b' && sample[8] == 'h' && sample[9] == 'i' && sample[10] == 't')
	{
		if (g_nemesis[id])
		{
			ArrayGetString(nemesis_pain, random_num(0, ArraySize(nemesis_pain) - 1), sound, charsmax(sound))
			emit_sound(id, channel, sound, volume, attn, flags, pitch)
		}
		else
		{
			ArrayGetString(zombie_pain, random_num(0, ArraySize(zombie_pain) - 1), sound, charsmax(sound))
			emit_sound(id, channel, sound, volume, attn, flags, pitch)
		}
		return FMRES_SUPERCEDE;
	}
Заменяем на:
	// Zombie being hit
	if (sample[7] == 'b' && sample[8] == 'h' && sample[9] == 'i' && sample[10] == 't')
	{
		if (g_nemesis[id])
		{
			ArrayGetString(nemesis_pain, random_num(0, ArraySize(nemesis_pain) - 1), sound, charsmax(sound))
			emit_sound(id, channel, sound, volume, attn, flags, pitch)
		}
		else
		{
			static pointers[10], end
			ArrayGetArray(pointer_class_sound_pain, g_zombieclass[id], pointers)
			
			for (new i; i < 10; i++)
			{
				if (pointers[i] != -1)
				end = i
			}
			ArrayGetString(class_sound_pain, random_num(pointers[0], pointers[end]), sound, charsmax(sound))
			emit_sound(id, channel, sound, volume, attn, flags, pitch)
		}
		return FMRES_SUPERCEDE;
	}

Находим:
// Play idle zombie sounds
public zombie_play_idle(taskid)
{
	// Round ended/new one starting
	if (g_endround || g_newround)
		return;
	
	static sound[64]
	
	// Last zombie?
	if (g_lastzombie[ID_BLOOD])
	{
		ArrayGetString(zombie_idle_last, random_num(0, ArraySize(zombie_idle_last) - 1), sound, charsmax(sound))
		emit_sound(ID_BLOOD, CHAN_VOICE, sound, 1.0, ATTN_NORM, 0, PITCH_NORM)
	}
	else
	{
		ArrayGetString(zombie_idle, random_num(0, ArraySize(zombie_idle) - 1), sound, charsmax(sound))
		emit_sound(ID_BLOOD, CHAN_VOICE, sound, 1.0, ATTN_NORM, 0, PITCH_NORM)
	}
}
Заменяем на:
// Play idle zombie sounds
public zombie_play_idle(taskid)
{
	// Round ended/new one starting
	if (g_endround || g_newround)
		return;
	
	static sound[64]
	
	// Last zombie?
	if (g_lastzombie[ID_BLOOD])
	{
		static pointers[10], end
		ArrayGetArray(pointer_class_sound_idle_last, g_zombieclass[ID_BLOOD], pointers)
		
		for (new i; i < 10; i++)
		{
			if (pointers[i] != -1)
			end = i
		}
		ArrayGetString(class_sound_idle_last, random_num(pointers[0], pointers[end]), sound, charsmax(sound))
		emit_sound(ID_BLOOD, CHAN_VOICE, sound, 1.0, ATTN_NORM, 0, PITCH_NORM)
	}
	else if(g_nemesis[ID_BLOOD])
	{
		ArrayGetString(nemesis_idle, random_num(0, ArraySize(nemesis_idle) - 1), sound, charsmax(sound))
		emit_sound(ID_BLOOD, CHAN_VOICE, sound, 1.0, ATTN_NORM, 0, PITCH_NORM)
	}
	else
	{
		static pointers[10], end
		ArrayGetArray(pointer_class_sound_idle, g_zombieclass[ID_BLOOD], pointers)

		for (new i; i < 10; i++)
		{
			if (pointers[i] != -1)
			end = i
		}
		ArrayGetString(class_sound_idle, random_num(pointers[0], pointers[end]), sound, charsmax(sound))
		emit_sound(ID_BLOOD, CHAN_VOICE, sound, 1.0, ATTN_NORM, 0, PITCH_NORM)
	}
}

Находим:
	// Zombie dies
	if (sample[7] == 'd' && ((sample[8] == 'i' && sample[9] == 'e') || (sample[8] == 'e' && sample[9] == 'a')))
	{
		ArrayGetString(zombie_die, random_num(0, ArraySize(zombie_die) - 1), sound, charsmax(sound))
		emit_sound(id, channel, sound, volume, attn, flags, pitch)
		return FMRES_SUPERCEDE;
	}

	// Zombie falls off
	if (sample[10] == 'f' && sample[11] == 'a' && sample[12] == 'l' && sample[13] == 'l')
	{
		ArrayGetString(zombie_fall, random_num(0, ArraySize(zombie_fall) - 1), sound, charsmax(sound))
		emit_sound(id, channel, sound, volume, attn, flags, pitch)
		return FMRES_SUPERCEDE;
	}
Заменяем на:
	// Zombie dies
	if (sample[7] == 'd' && ((sample[8] == 'i' && sample[9] == 'e') || (sample[8] == 'e' && sample[9] == 'a')))
	{
		if(g_nemesis[id])
			ArrayGetString(nemesis_die, random_num(0, ArraySize(nemesis_die) - 1), sound, charsmax(sound))
		else {	
			static pointers[10], end
			ArrayGetArray(pointer_class_sound_die, g_zombieclass[id], pointers)
			
			for (new i; i < 10; i++)
			{
				if (pointers[i] != -1)
					end = i
			}
			ArrayGetString(class_sound_die, random_num(pointers[0], pointers[end]), sound, charsmax(sound))
		}
		emit_sound(id, channel, sound, volume, attn, flags, pitch)
		return FMRES_SUPERCEDE;
	}

	// Zombie falls off
	if (sample[10] == 'f' && sample[11] == 'a' && sample[12] == 'l' && sample[13] == 'l')
	{
		if(g_nemesis[id])
			ArrayGetString(nemesis_fall, random_num(0, ArraySize(nemesis_fall) - 1), sound, charsmax(sound))
		else {
			static pointers[10], end
			ArrayGetArray(pointer_class_sound_fall, g_zombieclass[id], pointers)
			
			for (new i; i < 10; i++)
			{
				if (pointers[i] != -1)
				end = i
			}
			ArrayGetString(class_sound_fall, random_num(pointers[0], pointers[end]), sound, charsmax(sound))
		}
		emit_sound(id, channel, sound, volume, attn, flags, pitch)
		return FMRES_SUPERCEDE;
	}

Находим:
	// Randomly play burning zombie scream sounds (not for nemesis)
	if (!g_nemesis[ID_BURN] && !random_num(0, 20))
	{
		static sound[64]
		ArrayGetString(grenade_fire_player, random_num(0, ArraySize(grenade_fire_player) - 1), sound, charsmax(sound))
		emit_sound(ID_BURN, CHAN_VOICE, sound, 1.0, ATTN_NORM, 0, PITCH_NORM)
	}
Заменяем на:
	// Randomly play burning zombie scream sounds (not for nemesis)
	if (!g_nemesis[ID_BURN] && !random_num(0, 20))
	{
		static sound[64]
		static pointers[10], end
		ArrayGetArray(pointer_class_sound_burn, g_zombieclass[ID_BURN], pointers)
		
		for (new i; i < 10; i++)
		{
			if (pointers[i] != -1)
			end = i
		}
		ArrayGetString(class_sound_burn, random_num(pointers[0], pointers[end]), sound, charsmax(sound))
		emit_sound(ID_BURN, CHAN_VOICE, sound, 1.0, ATTN_NORM, 0, PITCH_NORM)
	}

Находим:
		case EXTRA_MADNESS: // Zombie Madness
		{
			// Increase madness purchase count for this round
			g_madnesscounter++
			
			g_nodamage[id] = true
			set_task(0.1, "zombie_aura", id+TASK_AURA, _, _, "b")
			set_task(get_pcvar_float(cvar_madnessduration), "madness_over", id+TASK_BLOOD)
			
			static sound[64]
			ArrayGetString(zombie_madness, random_num(0, ArraySize(zombie_madness) - 1), sound, charsmax(sound))
			emit_sound(id, CHAN_VOICE, sound, 1.0, ATTN_NORM, 0, PITCH_NORM)
		}
Заменяем на:
		case EXTRA_MADNESS: // Zombie Madness
		{
			// Increase madness purchase count for this round
			g_madnesscounter++
			
			g_nodamage[id] = true
			set_task(0.1, "zombie_aura", id+TASK_AURA, _, _, "b")
			set_task(get_pcvar_float(cvar_madnessduration), "madness_over", id+TASK_BLOOD)
			
			static sound[64]
			static pointers[10], end
			ArrayGetArray(pointer_class_sound_madness, g_zombieclass[id], pointers)
			
			for (new i; i < 10; i++)
			{
				if (pointers[i] != -1)
				end = i
			}
			ArrayGetString(class_sound_madness, random_num(pointers[0], pointers[end]), sound, charsmax(sound))
			emit_sound(id, CHAN_VOICE, sound, 1.0, ATTN_NORM, 0, PITCH_NORM)
		}

Находим:
	// Randomly play burning zombie scream sounds (not for nemesis)
	if (!g_nemesis[ID_BURN] && !random_num(0, 20))
	{
		static sound[64]
		ArrayGetString(grenade_fire_player, random_num(0, ArraySize(grenade_fire_player) - 1), sound, charsmax(sound))
		emit_sound(ID_BURN, CHAN_VOICE, sound, 1.0, ATTN_NORM, 0, PITCH_NORM)
	}
Заменяем на:
	// Randomly play burning zombie scream sounds (not for nemesis)
	if (!g_nemesis[ID_BURN] && !random_num(0, 20))
	{
		static sound[64]
		static pointers[10], end
		ArrayGetArray(pointer_class_sound_burn, g_zombieclass[ID_BURN], pointers)
		
		for (new i; i < 10; i++)
		{
			if (pointers[i] != -1)
			end = i
		}
		ArrayGetString(class_sound_burn, random_num(pointers[0], pointers[end]), sound, charsmax(sound))
		emit_sound(ID_BURN, CHAN_VOICE, sound, 1.0, ATTN_NORM, 0, PITCH_NORM)
	}

Находим:
	// Zombie attacks with knife
	if (sample[8] == 'k' && sample[9] == 'n' && sample[10] == 'i')
	{
		if (sample[14] == 's' && sample[15] == 'l' && sample[16] == 'a') // slash
		{
			ArrayGetString(zombie_miss_slash, random_num(0, ArraySize(zombie_miss_slash) - 1), sound, charsmax(sound))
			emit_sound(id, channel, sound, volume, attn, flags, pitch)
			return FMRES_SUPERCEDE;
		}
		if (sample[14] == 'h' && sample[15] == 'i' && sample[16] == 't') // hit
		{
			if (sample[17] == 'w') // wall
			{
				ArrayGetString(zombie_miss_wall, random_num(0, ArraySize(zombie_miss_wall) - 1), sound, charsmax(sound))
				emit_sound(id, channel, sound, volume, attn, flags, pitch)
				return FMRES_SUPERCEDE;
			}
			else
			{
				ArrayGetString(zombie_hit_normal, random_num(0, ArraySize(zombie_hit_normal) - 1), sound, charsmax(sound))
				emit_sound(id, channel, sound, volume, attn, flags, pitch)
				return FMRES_SUPERCEDE;
			}
		}
		if (sample[14] == 's' && sample[15] == 't' && sample[16] == 'a') // stab
		{
			ArrayGetString(zombie_hit_stab, random_num(0, ArraySize(zombie_hit_stab) - 1), sound, charsmax(sound))
			emit_sound(id, channel, sound, volume, attn, flags, pitch)
			return FMRES_SUPERCEDE;
		}
	}
Заменяем на:
	// Zombie attacks with knife
	if (sample[8] == 'k' && sample[9] == 'n' && sample[10] == 'i')
	{
		if (sample[14] == 's' && sample[15] == 'l' && sample[16] == 'a') // slash
		{
			if(g_nemesis[id])
				ArrayGetString(nemesis_miss_slash, random_num(0, ArraySize(nemesis_miss_slash) - 1), sound, charsmax(sound))
			else {
				static pointers[10], end
				ArrayGetArray(pointer_class_sound_miss_slash, g_zombieclass[id], pointers)
	
				for (new i; i < 10; i++)
				{
					if (pointers[i] != -1)
						end = i
				}
				ArrayGetString(class_sound_miss_slash, random_num(pointers[0], pointers[end]), sound, charsmax(sound))
			}
			emit_sound(id, channel, sound, volume, attn, flags, pitch)
			return FMRES_SUPERCEDE;
		}
		if (sample[14] == 'h' && sample[15] == 'i' && sample[16] == 't') // hit
		{
			if (sample[17] == 'w') // wall
			{
				if(g_nemesis[id])
					ArrayGetString(nemesis_miss_wall, random_num(0, ArraySize(nemesis_miss_wall) - 1), sound, charsmax(sound))
				else {
					static pointers[10], end
					ArrayGetArray(pointer_class_sound_miss_wall, g_zombieclass[id], pointers)
			
					for (new i; i < 10; i++)
					{
						if (pointers[i] != -1)
							end = i
					}
					ArrayGetString(class_sound_miss_wall, random_num(pointers[0], pointers[end]), sound, charsmax(sound))
				}
				emit_sound(id, channel, sound, volume, attn, flags, pitch)
				return FMRES_SUPERCEDE;
			}
			else
			{
				if(g_nemesis[id])
					ArrayGetString(nemesis_hit_normal, random_num(0, ArraySize(nemesis_hit_normal) - 1), sound, charsmax(sound))
				else {				
					static pointers[10], end
					ArrayGetArray(pointer_class_sound_hit_normal, g_zombieclass[id], pointers)
			
					for (new i; i < 10; i++)
					{
						if (pointers[i] != -1)
							end = i
					}
					ArrayGetString(class_sound_hit_normal, random_num(pointers[0], pointers[end]), sound, charsmax(sound))
				}
				emit_sound(id, channel, sound, volume, attn, flags, pitch)
				return FMRES_SUPERCEDE;
			}
		}
		if (sample[14] == 's' && sample[15] == 't' && sample[16] == 'a') // stab
		{
			if(g_nemesis[id])
				ArrayGetString(nemesis_hit_stab, random_num(0, ArraySize(nemesis_hit_stab) - 1), sound, charsmax(sound))
			else {	
				static pointers[10], end
				ArrayGetArray(pointer_class_sound_hit_stab, g_zombieclass[id], pointers)
			
				for (new i; i < 10; i++)
				{
					if (pointers[i] != -1)
						end = i
				}
				ArrayGetString(class_sound_hit_stab, random_num(pointers[0], pointers[end]), sound, charsmax(sound))
			}
			emit_sound(id, channel, sound, volume, attn, flags, pitch)
			return FMRES_SUPERCEDE;
		}
	}

Находим:
	// Parse if present
	if (file_exists(path))
	{
		// Open zombie classes file for reading
		file = fopen(path, "rt")
		
		while (file && !feof(file))
		{
			// Read one line at a time
			fgets(file, linedata, charsmax(linedata))
			
			// Replace newlines with a null character to prevent headaches
			replace(linedata, charsmax(linedata), "^n", "")
			
			// Blank line or comment
			if (!linedata[0] || linedata[0] == ';') continue;
			
			// New class starting
			if (linedata[0] == '[')
			{
				// Remove first and last characters (braces)
				linedata[strlen(linedata) - 1] = 0
				copy(linedata, charsmax(linedata), linedata[1])
				
				// Store its real name for future reference
				ArrayPushString(g_zclass2_realname, linedata)
				continue;
			}
			
			// Get key and value(s)
			strtok(linedata, key, charsmax(key), value, charsmax(value), '=')
			
			// Trim spaces
			trim(key)
			trim(value)
			
			if (equal(key, "NAME"))
				ArrayPushString(g_zclass2_name, value)
			else if (equal(key, "INFO"))
				ArrayPushString(g_zclass2_info, value)
			else if (equal(key, "MODELS"))
			{
				// Set models start index
				ArrayPushCell(g_zclass2_modelsstart, ArraySize(g_zclass2_playermodel))
				
				// Parse class models
				while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
				{
					// Trim spaces
					trim(key)
					trim(value)
					
					// Add to class models array
					ArrayPushString(g_zclass2_playermodel, key)
					ArrayPushCell(g_zclass2_modelindex, -1)
				}
				
				// Set models end index
				ArrayPushCell(g_zclass2_modelsend, ArraySize(g_zclass2_playermodel))
			}
			else if (equal(key, "CLAWMODEL"))
				ArrayPushString(g_zclass2_clawmodel, value)
			else if (equal(key, "HEALTH"))
				ArrayPushCell(g_zclass2_hp, str_to_num(value))
			else if (equal(key, "SPEED"))
				ArrayPushCell(g_zclass2_spd, str_to_num(value))
			else if (equal(key, "GRAVITY"))
				ArrayPushCell(g_zclass2_grav, str_to_float(value))
			else if (equal(key, "KNOCKBACK"))
				ArrayPushCell(g_zclass2_kb, str_to_float(value))
		}
		if (file) fclose(file)
	}
Заменяем на:
	// Parse if present
	if (file_exists(path))
	{
		// Open zombie classes file for reading
		file = fopen(path, "rt")
		
		while (file && !feof(file))
		{
			static pos, temparr[64]

			// Read one line at a time
			fgets(file, linedata, charsmax(linedata))
			
			// Replace newlines with a null character to prevent headaches
			replace(linedata, charsmax(linedata), "^n", "")
			
			// Blank line or comment
			if (!linedata[0] || linedata[0] == ';') continue;
			
			// New class starting
			if (linedata[0] == '[')
			{
				// Remove first and last characters (braces)
				linedata[strlen(linedata) - 1] = 0
				copy(linedata, charsmax(linedata), linedata[1])
				
				// Store its real name for future reference
				ArrayPushString(g_zclass2_realname, linedata)
				continue;
			}
			
			// Get key and value(s)
			strtok(linedata, key, charsmax(key), value, charsmax(value), '=')
			
			// Trim spaces
			trim(key)
			trim(value)
			
			if (equal(key, "NAME"))
				ArrayPushString(g_zclass2_name, value)
			else if (equal(key, "INFO"))
				ArrayPushString(g_zclass2_info, value)
			else if (equal(key, "MODELS"))
			{
				// Set models start index
				ArrayPushCell(g_zclass2_modelsstart, ArraySize(g_zclass2_playermodel))
				
				// Parse class models
				while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
				{
					// Trim spaces
					trim(key)
					trim(value)
					
					// Add to class models array
					ArrayPushString(g_zclass2_playermodel, key)
					ArrayPushCell(g_zclass2_modelindex, -1)
				}
				
				// Set models end index
				ArrayPushCell(g_zclass2_modelsend, ArraySize(g_zclass2_playermodel))
			}
			else if (equal(key, "CLAWMODEL"))
				ArrayPushString(g_zclass2_clawmodel, value)
			else if (equal(key, "HEALTH"))
				ArrayPushCell(g_zclass2_hp, str_to_num(value))
			else if (equal(key, "SPEED"))
				ArrayPushCell(g_zclass2_spd, str_to_num(value))
			else if (equal(key, "GRAVITY"))
				ArrayPushCell(g_zclass2_grav, str_to_float(value))
			else if (equal(key, "KNOCKBACK"))
				ArrayPushCell(g_zclass2_kb, str_to_float(value))
			else if (equal(key, "INFECT"))
			{
				pos = 0
				arrayset(temparr, -1, sizeof(temparr))
				while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
				{
					// Trim spaces
					trim(key)
					trim(value)
			
					ArrayPushString(class_sound_infect, key)
					temparr[pos++] = ArraySize(class_sound_infect) - 1
				}
				ArrayPushArray(pointer_class_sound_infect, temparr)
			}
			else if (equal(key, "BURN"))
			{
				pos = 0
				arrayset(temparr, -1, sizeof(temparr))
				while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
				{
					// Trim spaces
					trim(key)
					trim(value)
					
					ArrayPushString(class_sound_burn, key)
					temparr[pos++] = ArraySize(class_sound_burn) - 1
				}
				ArrayPushArray(pointer_class_sound_burn, temparr)
			}
			else if (equal(key, "PAIN"))
			{
				pos = 0
				arrayset(temparr, -1, sizeof(temparr))
				while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
				{
					// Trim spaces
					trim(key)
					trim(value)
					
					ArrayPushString(class_sound_pain, key)
					temparr[pos++] = ArraySize(class_sound_pain) - 1
				}
				ArrayPushArray(pointer_class_sound_pain, temparr)
			}
			else if (equal(key, "DIE"))
			{
				pos = 0
				arrayset(temparr, -1, sizeof(temparr))
				while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
				{
					// Trim spaces
					trim(key)
					trim(value)
					
					ArrayPushString(class_sound_die, key)
					temparr[pos++] = ArraySize(class_sound_die) - 1
				}
				ArrayPushArray(pointer_class_sound_die, temparr)
			}
			else if (equal(key, "IDLE"))
			{
				pos = 0
				arrayset(temparr, -1, sizeof(temparr))
				while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
				{
					// Trim spaces
					trim(key)
					trim(value)
					
					ArrayPushString(class_sound_idle, key)
					temparr[pos++] = ArraySize(class_sound_idle) - 1
				}
				ArrayPushArray(pointer_class_sound_idle, temparr)
			}
			else if (equal(key, "IDLE LAST"))
			{
				pos = 0
				arrayset(temparr, -1, sizeof(temparr))
				while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
				{
					// Trim spaces
					trim(key)
					trim(value)
					
					ArrayPushString(class_sound_idle_last, key)
					temparr[pos++] = ArraySize(class_sound_idle_last) - 1
				}
				ArrayPushArray(pointer_class_sound_idle_last, temparr)
			}
			else if (equal(key, "MISS SLASH"))
			{
				pos = 0
				arrayset(temparr, -1, sizeof(temparr))
				while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
				{
					// Trim spaces
					trim(key)
					trim(value)
					
					ArrayPushString(class_sound_miss_slash, key)
					temparr[pos++] = ArraySize(class_sound_miss_slash) - 1
				}
				ArrayPushArray(pointer_class_sound_miss_slash, temparr)
			}
			else if (equal(key, "MISS WALL"))
			{
				pos = 0
				arrayset(temparr, -1, sizeof(temparr))
				while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
				{
					// Trim spaces
					trim(key)
					trim(value)
					
					ArrayPushString(class_sound_miss_wall, key)
					temparr[pos++] = ArraySize(class_sound_miss_wall) - 1
				}
				ArrayPushArray(pointer_class_sound_miss_wall, temparr)
			}
			else if (equal(key, "HIT NORMAL"))
			{
				pos = 0
				arrayset(temparr, -1, sizeof(temparr))
				while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
				{
					// Trim spaces
					trim(key)
					trim(value)
					
					ArrayPushString(class_sound_hit_normal, key)
					temparr[pos++] = ArraySize(class_sound_hit_normal) - 1
				}
				ArrayPushArray(pointer_class_sound_hit_normal, temparr)
			}
			else if (equal(key, "HIT STAB"))
			{
				pos = 0
				arrayset(temparr, -1, sizeof(temparr))
				while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
				{
					// Trim spaces
					trim(key)
					trim(value)
					
					ArrayPushString(class_sound_hit_stab, key)
					temparr[pos++] = ArraySize(class_sound_hit_stab) - 1
				}
				ArrayPushArray(pointer_class_sound_hit_stab, temparr)
			}
			else if (equal(key, "FALL"))
			{
				pos = 0
				arrayset(temparr, -1, sizeof(temparr))
				while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
				{
					// Trim spaces
					trim(key)
					trim(value)
					
					ArrayPushString(class_sound_fall, key)
					temparr[pos++] = ArraySize(class_sound_fall) - 1
				}
				ArrayPushArray(pointer_class_sound_fall, temparr)
			}
			else if (equal(key, "MADNESS"))
			{
				pos = 0
				arrayset(temparr, -1, sizeof(temparr))
				while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
				{
					// Trim spaces
					trim(key)
					trim(value)
					
					ArrayPushString(class_sound_madness, key)
					temparr[pos++] = ArraySize(class_sound_madness) - 1
				}
				ArrayPushArray(pointer_class_sound_madness, temparr)
			}
		}
		if (file) fclose(file)
	}

Находим:
save_customization()
{
	 new i, k, buffer[512]
	 
	 // Build zombie classes file path
	 new path[64]
	 get_configsdir(path, charsmax(path))
	 format(path, charsmax(path), "%s/%s", path, ZP_ZOMBIECLASSES_FILE)
	 
	 // Open zombie classes file for appending data
	 new file = fopen(path, "at"), size = ArraySize(g_zclass_name)
	 
	 // Add any new zombie classes data at the end if needed
	 for (i = 0; i < size; i++)
	 {
		  if (ArrayGetCell(g_zclass_new, i))
		  {
				// Add real name
				ArrayGetString(g_zclass_name, i, buffer, charsmax(buffer))
				format(buffer, charsmax(buffer), "^n[%s]", buffer)
				fputs(file, buffer)
				
				// Add caption
				ArrayGetString(g_zclass_name, i, buffer, charsmax(buffer))
				format(buffer, charsmax(buffer), "^nNAME = %s", buffer)
				fputs(file, buffer)
				
				// Add info
				ArrayGetString(g_zclass_info, i, buffer, charsmax(buffer))
				format(buffer, charsmax(buffer), "^nINFO = %s", buffer)
				fputs(file, buffer)
				
				// Add models
				for (k = ArrayGetCell(g_zclass_modelsstart, i); k < ArrayGetCell(g_zclass_modelsend, i); k++)
				{
					 if (k == ArrayGetCell(g_zclass_modelsstart, i))
					 {
						  // First model, overwrite buffer
						  ArrayGetString(g_zclass_playermodel, k, buffer, charsmax(buffer))
					 }
					 else
					 {
						  // Successive models, append to buffer
						  ArrayGetString(g_zclass_playermodel, k, path, charsmax(path))
						  format(buffer, charsmax(buffer), "%s , %s", buffer, path)
					 }
				}
				format(buffer, charsmax(buffer), "^nMODELS = %s", buffer)
				fputs(file, buffer)
				
				// Add clawmodel
				ArrayGetString(g_zclass_clawmodel, i, buffer, charsmax(buffer))
				format(buffer, charsmax(buffer), "^nCLAWMODEL = %s", buffer)
				fputs(file, buffer)
				
				// Add health
				formatex(buffer, charsmax(buffer), "^nHEALTH = %d", ArrayGetCell(g_zclass_hp, i))
				fputs(file, buffer)
				
				// Add speed
				formatex(buffer, charsmax(buffer), "^nSPEED = %d", ArrayGetCell(g_zclass_spd, i))
				fputs(file, buffer)
				
				// Add gravity
				formatex(buffer, charsmax(buffer), "^nGRAVITY = %.2f", Float:ArrayGetCell(g_zclass_grav, i))
				fputs(file, buffer)
				
				// Add knockback
				formatex(buffer, charsmax(buffer), "^nKNOCKBACK = %.2f^n", Float:ArrayGetCell(g_zclass_kb, i))
				fputs(file, buffer)
		  }
	 }
Заменяем на:
save_customization()
{
	 new i, k, buffer[512]
	 
	 // Build zombie classes file path
	 new path[64]
	 get_configsdir(path, charsmax(path))
	 format(path, charsmax(path), "%s/%s", path, ZP_ZOMBIECLASSES_FILE)
	 
	 // Open zombie classes file for appending data
	 new file = fopen(path, "at"), size = ArraySize(g_zclass_name)
	 
	 // Add any new zombie classes data at the end if needed
	 for (i = 0; i < size; i++)
	 {
		  if (ArrayGetCell(g_zclass_new, i))
		  {
				// Add real name
				ArrayGetString(g_zclass_name, i, buffer, charsmax(buffer))
				format(buffer, charsmax(buffer), "^n[%s]", buffer)
				fputs(file, buffer)
				
				// Add caption
				ArrayGetString(g_zclass_name, i, buffer, charsmax(buffer))
				format(buffer, charsmax(buffer), "^nNAME = %s", buffer)
				fputs(file, buffer)
				
				// Add info
				ArrayGetString(g_zclass_info, i, buffer, charsmax(buffer))
				format(buffer, charsmax(buffer), "^nINFO = %s", buffer)
				fputs(file, buffer)
				
				// Add models
				for (k = ArrayGetCell(g_zclass_modelsstart, i); k < ArrayGetCell(g_zclass_modelsend, i); k++)
				{
					 if (k == ArrayGetCell(g_zclass_modelsstart, i))
					 {
						  // First model, overwrite buffer
						  ArrayGetString(g_zclass_playermodel, k, buffer, charsmax(buffer))
					 }
					 else
					 {
						  // Successive models, append to buffer
						  ArrayGetString(g_zclass_playermodel, k, path, charsmax(path))
						  format(buffer, charsmax(buffer), "%s , %s", buffer, path)
					 }
				}
				format(buffer, charsmax(buffer), "^nMODELS = %s", buffer)
				fputs(file, buffer)
				
				// Add clawmodel
				ArrayGetString(g_zclass_clawmodel, i, buffer, charsmax(buffer))
				format(buffer, charsmax(buffer), "^nCLAWMODEL = %s", buffer)
				fputs(file, buffer)
				
				// Add health
				formatex(buffer, charsmax(buffer), "^nHEALTH = %d", ArrayGetCell(g_zclass_hp, i))
				fputs(file, buffer)
				
				// Add speed
				formatex(buffer, charsmax(buffer), "^nSPEED = %d", ArrayGetCell(g_zclass_spd, i))
				fputs(file, buffer)
				
				// Add gravity
				formatex(buffer, charsmax(buffer), "^nGRAVITY = %.2f", Float:ArrayGetCell(g_zclass_grav, i))
				fputs(file, buffer)
				
				// Add knockback
				formatex(buffer, charsmax(buffer), "^nKNOCKBACK = %.2f", Float:ArrayGetCell(g_zclass_kb, i))
				fputs(file, buffer)

				// Add infect sound
				fputs(file, "^nINFECT = zombie_plague/zombie_infec1.wav , zombie_plague/zombie_infec2.wav , zombie_plague/zombie_infec3.wav")
				
				// Add burn sound
				fputs(file, "^nBURN = zombie_plague/zombie_burn3.wav , zombie_plague/zombie_burn4.wav , zombie_plague/zombie_burn5.wav , zombie_plague/zombie_burn6.wav , zombie_plague/zombie_burn7.wav")
				
				// Add pain sound
				fputs(file, "^nPAIN = zombie_plague/zombie_pain1.wav , zombie_plague/zombie_pain2.wav , zombie_plague/zombie_pain3.wav , zombie_plague/zombie_pain4.wav , zombie_plague/zombie_pain5.wav")
				
				// Add die sound
				fputs(file, "^nDIE = zombie_plague/zombie_die1.wav , zombie_plague/zombie_die2.wav , zombie_plague/zombie_die3.wav , zombie_plague/zombie_die4.wav , zombie_plague/zombie_die5.wav")
				
				// Add idle sound
				fputs(file, "^nIDLE = zombie_plague/zombie_brains1.wav , zombie_plague/zombie_brains2.wav")
				
				// Add idle last sound
				fputs(file, "^nIDLE LAST = zombie_plague/zombie_brains1.wav , zombie_plague/zombie_brains2.wav")
				
				// Add miss slash sound
				fputs(file, "^nMISS SLASH = weapons/knife_slash1.wav , weapons/knife_slash2.wav")
				
				// Add miss wall sound
				fputs(file, "^nMISS WALL = weapons/knife_hitwall1.wav")
				
				// Add hit normal sound
				fputs(file, "^nHIT NORMAL = weapons/knife_hit1.wav , weapons/knife_hit2.wav , weapons/knife_hit3.wav , weapons/knife_hit4.wav")
				
				// Add hit stab sound
				fputs(file, "^nHIT STAB = weapons/knife_stab.wav")

				// Add fall sound
				fputs(file, "^nFALL = zombie_plague/zombie_fall1.wav")

				// Add madness sound
				fputs(file, "^nMADNESS = zombie_plague/zombie_madness1.wav^n")
		  }
	 }

Находим:
					 else if (equal(key, "WIN NO ONE"))
					 {
						  // Parse sounds
						  while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
						  {
								// Trim spaces
								trim(key)
								trim(value)
								
								// Add to sounds array
								ArrayPushString(sound_win_no_one, key)
								ArrayPushCell(sound_win_no_one_ismp3, equal(key[strlen(key)-4], ".mp3") ? 1 : 0)
						  }
					 }
Добавляем ниже:
					 else if (equal(key, "NEMESIS PAIN"))
					 {
						  // Parse sounds
						  while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
						  {
								// Trim spaces
								trim(key)
								trim(value)
								
								// Add to sounds array
								ArrayPushString(nemesis_pain, key)
						  }
					 }
					 else if (equal(key, "NEMESIS IDLE"))
					 {
						  // Parse sounds
						  while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
						  {
								// Trim spaces
								trim(key)
								trim(value)
								
								// Add to sounds array
								ArrayPushString(nemesis_idle, key)
						  }
					 }
					 else if (equal(key, "NEMESIS DIE"))
					 {
						  // Parse sounds
						  while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
						  {
								// Trim spaces
								trim(key)
								trim(value)
								
								// Add to sounds array
								ArrayPushString(nemesis_die, key)
						  }
					 }
					 else if (equal(key, "NEMESIS FALL"))
					 {
						  // Parse sounds
						  while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
						  {
								// Trim spaces
								trim(key)
								trim(value)
								
								// Add to sounds array
								ArrayPushString(nemesis_fall, key)
						  }
					 }
					 else if (equal(key, "NEMESIS MISS SLASH"))
					 {
						  // Parse sounds
						  while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
						  {
								// Trim spaces
								trim(key)
								trim(value)
								
								// Add to sounds array
								ArrayPushString(nemesis_miss_slash, key)
						  }
					 }
					 else if (equal(key, "NEMESIS MISS WALL"))
					 {
						  // Parse sounds
						  while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
						  {
								// Trim spaces
								trim(key)
								trim(value)
								
								// Add to sounds array
								ArrayPushString(nemesis_miss_wall, key)
						  }
					 }
					 else if (equal(key, "NEMESIS HIT NORMAL"))
					 {
						  // Parse sounds
						  while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
						  {
								// Trim spaces
								trim(key)
								trim(value)
								
								// Add to sounds array
								ArrayPushString(nemesis_hit_normal, key)
						  }
					 }
					 else if (equal(key, "NEMESIS HIT STAB"))
					 {
						  // Parse sounds
						  while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
						  {
								// Trim spaces
								trim(key)
								trim(value)
								
								// Add to sounds array
								ArrayPushString(nemesis_hit_stab, key)
						  }
					 }

Находим в // Customization vars и удаляем:
Array:zombie_infect,
Array:zombie_pain,
Array:zombie_idle,
Array:zombie_idle_last,
Array:zombie_die,
Array:zombie_fall,
Array:zombie_madness,
Array:grenade_fire_player,
Array:zombie_miss_slash,
Array:zombie_miss_wall,
Array:zombie_hit_normal,
Array:zombie_hit_stab,

Находим в public plugin_precache() и удаляем:
	 zombie_infect = ArrayCreate(64, 1)
	 zombie_pain = ArrayCreate(64, 1)
	 zombie_idle = ArrayCreate(64, 1)
	 zombie_idle_last = ArrayCreate(64, 1)
	 zombie_die = ArrayCreate(64, 1)
	 zombie_fall = ArrayCreate(64, 1)
	 zombie_madness = ArrayCreate(64, 1)
	 grenade_fire_player = ArrayCreate(64, 1)
	 zombie_miss_slash = ArrayCreate(64, 1)
	 zombie_miss_wall = ArrayCreate(64, 1)
	 zombie_hit_normal = ArrayCreate(64, 1)
	 zombie_hit_stab = ArrayCreate(64, 1)

	 for (i = 0; i < ArraySize(zombie_infect); i++)
	 {
		  ArrayGetString(zombie_infect, i, buffer, charsmax(buffer))
		  engfunc(EngFunc_PrecacheSound, buffer)
	 }
	 for (i = 0; i < ArraySize(zombie_pain); i++)
	 {
		  ArrayGetString(zombie_pain, i, buffer, charsmax(buffer))
		  engfunc(EngFunc_PrecacheSound, buffer)
	 }
	 for (i = 0; i < ArraySize(zombie_idle); i++)
	 {
		  ArrayGetString(zombie_idle, i, buffer, charsmax(buffer))
		  engfunc(EngFunc_PrecacheSound, buffer)
	 }
	 for (i = 0; i < ArraySize(zombie_idle_last); i++)
	 {
		  ArrayGetString(zombie_idle_last, i, buffer, charsmax(buffer))
		  engfunc(EngFunc_PrecacheSound, buffer)
	 }
	 for (i = 0; i < ArraySize(zombie_die); i++)
	 {
		  ArrayGetString(zombie_die, i, buffer, charsmax(buffer))
		  engfunc(EngFunc_PrecacheSound, buffer)
	 }
	 for (i = 0; i < ArraySize(zombie_fall); i++)
	 {
		  ArrayGetString(zombie_fall, i, buffer, charsmax(buffer))
		  engfunc(EngFunc_PrecacheSound, buffer)
	 }
	 for (i = 0; i < ArraySize(zombie_madness); i++)
	 {
		  ArrayGetString(zombie_madness, i, buffer, charsmax(buffer))
		  engfunc(EngFunc_PrecacheSound, buffer)
	 }
	 for (i = 0; i < ArraySize(grenade_fire_player); i++)
	 {
		  ArrayGetString(grenade_fire_player, i, buffer, charsmax(buffer))
		  engfunc(EngFunc_PrecacheSound, buffer)
	 }
	 for (i = 0; i < ArraySize(zombie_miss_slash); i++)
	 {
		  ArrayGetString(zombie_miss_slash, i, buffer, charsmax(buffer))
		  engfunc(EngFunc_PrecacheSound, buffer)
	 }
	 for (i = 0; i < ArraySize(zombie_miss_wall); i++)
	 {
		  ArrayGetString(zombie_miss_wall, i, buffer, charsmax(buffer))
		  engfunc(EngFunc_PrecacheSound, buffer)
	 }
	 for (i = 0; i < ArraySize(zombie_hit_normal); i++)
	 {
		  ArrayGetString(zombie_hit_normal, i, buffer, charsmax(buffer))
		  engfunc(EngFunc_PrecacheSound, buffer)
	 }
	 for (i = 0; i < ArraySize(zombie_hit_stab); i++)
	 {
		  ArrayGetString(zombie_hit_stab, i, buffer, charsmax(buffer))
		  engfunc(EngFunc_PrecacheSound, buffer)
	 }
Находим в case SECTION_SOUNDS: и удаляем:
					 else if (equal(key, "ZOMBIE INFECT"))
					 {
						  // Parse sounds
						  while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
						  {
								// Trim spaces
								trim(key)
								trim(value)
								
								// Add to sounds array
								ArrayPushString(zombie_infect, key)
						  }
					 }
					 else if (equal(key, "ZOMBIE PAIN"))
					 {
						  // Parse sounds
						  while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
						  {
								// Trim spaces
								trim(key)
								trim(value)
								
								// Add to sounds array
								ArrayPushString(zombie_pain, key)
						  }
					 }
					 else if (equal(key, "ZOMBIE IDLE"))
					 {
						  // Parse sounds
						  while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
						  {
								// Trim spaces
								trim(key)
								trim(value)
								
								// Add to sounds array
								ArrayPushString(zombie_idle, key)
						  }
					 }
					 else if (equal(key, "ZOMBIE IDLE LAST"))
					 {
						  // Parse sounds
						  while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
						  {
								// Trim spaces
								trim(key)
								trim(value)
								
								// Add to sounds array
								ArrayPushString(zombie_idle_last, key)
						  }
					 }
					 else if (equal(key, "ZOMBIE DIE"))
					 {
						  // Parse sounds
						  while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
						  {
								// Trim spaces
								trim(key)
								trim(value)
								
								// Add to sounds array
								ArrayPushString(zombie_die, key)
						  }
					 }
					 else if (equal(key, "ZOMBIE FALL"))
					 {
						  // Parse sounds
						  while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
						  {
								// Trim spaces
								trim(key)
								trim(value)
								
								// Add to sounds array
								ArrayPushString(zombie_fall, key)
						  }
					 }
					 else if (equal(key, "ZOMBIE MADNESS"))
					 {
						  // Parse sounds
						  while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
						  {
								// Trim spaces
								trim(key)
								trim(value)
								
								// Add to sounds array
								ArrayPushString(zombie_madness, key)
						  }
					 }
					 else if (equal(key, "GRENADE FIRE PLAYER"))
					 {
						  // Parse sounds
						  while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
						  {
								// Trim spaces
								trim(key)
								trim(value)
								
								// Add to sounds array
								ArrayPushString(grenade_fire_player, key)
						  }
					 }
					 else if (equal(key, "ZOMBIE MISS SLASH"))
					 {
						  // Parse sounds
						  while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
						  {
								// Trim spaces
								trim(key)
								trim(value)
								
								// Add to sounds array
								ArrayPushString(zombie_miss_slash, key)
						  }
					 }
					 else if (equal(key, "ZOMBIE MISS WALL"))
					 {
						  // Parse sounds
						  while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
						  {
								// Trim spaces
								trim(key)
								trim(value)
								
								// Add to sounds array
								ArrayPushString(zombie_miss_wall, key)
						  }
					 }
					 else if (equal(key, "ZOMBIE HIT NORMAL"))
					 {
						  // Parse sounds
						  while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
						  {
								// Trim spaces
								trim(key)
								trim(value)
								
								// Add to sounds array
								ArrayPushString(zombie_hit_normal, key)
						  }
					 }
					 else if (equal(key, "ZOMBIE HIT STAB"))
					 {
						  // Parse sounds
						  while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
						  {
								// Trim spaces
								trim(key)
								trim(value)
								
								// Add to sounds array
								ArrayPushString(zombie_hit_stab, key)
						  }
					 }

NEMESIS HIT STAB = Ваш путь к звукам/Ваш звук.wav
NEMESIS HIT NORMAL = Ваш путь к звукам/Ваш звук.wav
NEMESIS MISS WALL = Ваш путь к звукам/Ваш звук.wav
NEMESIS MISS SLASH = Ваш путь к звукам/Ваш звук.wav
NEMESIS PAIN = Ваш путь к звукам/Ваш звук.wav
NEMESIS DIE = Ваш путь к звукам/Ваш звук.wav
NEMESIS IDLE = Ваш путь к звукам/Ваш звук.wav

-----------------------------------------------------------
Array:nemesis_pain,
-----------------------------------------------------------
nemesis_pain = ArrayCreate(64, 1)
-----------------------------------------------------------
	 for (i = 0; i < ArraySize(nemesis_pain); i++)
	 {
		  ArrayGetString(nemesis_pain, i, buffer, charsmax(buffer))
		  engfunc(EngFunc_PrecacheSound, buffer)
	 }
-----------------------------------------------------------
					 else if (equal(key, "NEMESIS PAIN"))
					 {
						  // Parse sounds
						  while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
						  {
								// Trim spaces
								trim(key)
								trim(value)
								
								// Add to sounds array
								ArrayPushString(nemesis_pain, key)
						  }
					 }
-----------------------------------------------------------